# 0.定义一个函数，求一元二次方程的解
# ax**2 + bx + c = 0



import math

# math.sqrt()

def f(a,b,c):
    # 判断delta>=0
    delta = b**2 - 4*a*c
    if delta < 0:
        print('此方程无实数解')
        return None
    else:
        x1 = (-b + math.sqrt(delta))/(2*a)
        x2 = (-b - math.sqrt(delta))/(2*a)
        return x1,x2

x1,x2 = f(1,2,1)
print(x1,x2)

# 1.定义一个函数，计算任意个数字的乘积



# 2.数列求和
# 有数列为：9，99，999，...，9999999999。要求使用程序计算此数列的和，并在控制台输出结果。
# 1 11 111..
# 2 22 222..


# 3. 有数列：1/1+1/2+1/3…+1/n（n>=2）。
#     要求使用交互的方式计算此数列的和：用户在控制台录入需要计算的整数 n 的值，
#     程序计算此数列的和，并在控制台输出结果。



# 4. 打印九九乘法表(双重循环)
# 1*1=1
# 2*1=2   2*2=4
# 3*1=3   3*2=6   3*3=9
# 4*1=4   4*2=8   4*3=12  4*4=16
# 5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
# 6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
# 7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
# 8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
# 9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81
for i in range(1,10):
    for j in range(1,i+1):
        print('%d*%d=%d'%(i,j,i*j),end='\t')
    print()


# 5. 用for循环实现阶乘
# n! = 1*2*3....*n


# 6. 使用冒泡排(Bubble Sort)序法对下面的列表进行升序排序:(双重循环)(选做)
#     [23,8,33,4,88] -> [4,8,23,33,88]
# 算法的时间复杂度-大O表示法：O(logn) O(n) O(n**2)
# 空间复杂度
'''
升序
    23,8,33,4,88
    8 23 33 4 88
    8 23 33 4 88
    8 23 4 33 88
    8 23 4 33 88


    8 23 4 33 88
    8 23 4 33 88
    8 4 23 33 88
    8 4 23 33 88
'''
# 程序 = 算法 + 数据结构

def sort(data):
    # 获取列表的长度
    length = len(data)

    for i in range(length-1):
        for j in range(0,length-i-1):
            if data[j] > data[j+1]:
                # t = data[j]
                # data[j] = data[j+1]
                # data[j+1] = t
                data[j],data[j+1] = data[j+1],data[j]

    return data



data = [23,8,33,4,88]

print(data)
data = sort(data)
print(data)

    
# 7. 用递归函数实现fibonacci数列某一项的求解
#     1 2 3 4 5 6 7  8   9  10  20
#     1 1 2 3 5 8 13 21 34 55... ?
#     f(n) = f(n-1)+f(n-2)

def fib(n):
    if n==1 or n==2:
        return 1
    return fib(n-1)+fib(n-2)

print(fib(7))
print(fib(10))
print(fib(20))



# 8. 用递归实现汉诺塔hanoi游戏(选做)
#    规则:一次只能移动一个盘子
#        小盘子永远要在大盘子的上面
#     输出结果：
#     A —> B
#     A -> C
#     B -> C
#     move(n,a,b,c)
#     move(1,'C','B','A')
'''
A -> B
A -> C
B -> C
'''
def move(n,a,b,c):
    if n==1:
        print(a,'->',c)
    else:
        move(n-1,a,c,b)
        move(1,a,b,c)
        move(n-1,b,a,c)

# move(2,'A','B','C')
move(3,'A','B','C')



